home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume1 / xfig / patch4 < prev    next >
Encoding:
Text File  |  1988-08-30  |  42.4 KB  |  1,639 lines
  1. Path: uunet!wyse!mikew
  2. From: mikew@wyse.wyse.com (Mike Wexler)
  3. Newsgroups: comp.sources.x
  4. Subject: v01i017:  xfig: a MacDraw like graphics editor, Patch4
  5. Message-ID: <1668@wyse.wyse.com>
  6. Date: 30 Aug 88 17:24:16 GMT
  7. Organization: Wyse Technology, San Jose
  8. Lines: 1628
  9. Approved: mikew@wyse.com
  10.  
  11. Submitted-by: dana@thumper.bellcore.com (Dana A. Chee)
  12. Posting-number: Volume 1, Issue 17
  13. Archive-name: xfig/patch4
  14.  
  15.  
  16.  
  17.  
  18. Below are the patches which incorportate the changes that John Kohl
  19. announced in comp.windows.x.  This is patch 4 (in keeping with expo)
  20. and is being submitted to comp.sources.x and stored on expo.
  21.  
  22. It should create a patch file (since I didn't have one).  The reason
  23. it is patchlevel 3 is to stay in line with the minor version number
  24. (which is now 3).
  25.  
  26.             Dana Chee
  27.             Bellcore
  28.             MRE 2Q-250
  29.             (201) 829-4488
  30.             dana@bellcore.com
  31. ==================== xfig.patch.4
  32. diff -c /dev/null patchlevel.h
  33. *** /dev/null    Fri Aug 26 09:30:01 1988
  34. --- patchlevel.h    Fri Aug 26 09:06:45 1988
  35. ***************
  36. *** 0 ****
  37. --- 1 ----
  38. + #define PATCHLEVEL 3
  39. diff -c README.X11.orig README.X11
  40. *** README.X11.orig    Fri Aug 12 22:30:14 1988
  41. --- README.X11    Fri Aug 26 10:28:14 1988
  42. ***************
  43. *** 61,63 ****
  44. --- 61,78 ----
  45.           Dana Chee of Bellcore contributed lots of cleanups
  46.           and put right some features I didn't know how
  47.           to do properly. (Thanks, Dana.) Released to world.
  48. + 
  49. + xfig 1.4.2:
  50. + 
  51. + 23 Aug 88     Dana Chee (Bellcore)
  52. +           Fixed color, added mouse tracking option.
  53. + 
  54. + xfig 1.4.3:
  55. + 
  56. + 26 Aug 88     Dana Chee (Bellcore)
  57. +           Added John Kohl's changes to fix color and make
  58. +           inverse video work on a monochrome display.
  59. +           Allow scaling of compound objects on a side as well as
  60. +           a corner.
  61. +           Allow compound objects within a compound.
  62. + 
  63. diff -c /tmp/panel.c panel.c
  64. *** /tmp/panel.c    Fri Aug 26 09:38:46 1988
  65. --- panel.c    Thu Aug 25 11:25:16 1988
  66. ***************
  67. *** 132,138 ****
  68. --- 132,144 ----
  69.       { XtNheight, (XtArgVal)0 },
  70.       { XtNhSpace, (XtArgVal)SWITCH_ICON_SPACING },
  71.       { XtNvSpace, (XtArgVal)SWITCH_ICON_SPACING },
  72. +     /* Fix the size of the panel window by chaining both top & bottom
  73. +        to the top, and both left & right to the right */
  74. +     { XtNtop, (XtArgVal)XtChainTop},
  75. +     { XtNbottom, (XtArgVal)XtChainTop},
  76.       { XtNleft, (XtArgVal)XtChainLeft },
  77. +     { XtNright, (XtArgVal)XtChainLeft },
  78. +     { XtNresizable, (XtArgVal) FALSE },
  79.   };
  80.   
  81.   extern void button_select();
  82. ***************
  83. *** 152,157 ****
  84. --- 158,164 ----
  85.       { XtNheight, (XtArgVal)0 },
  86.       { XtNbackgroundPixmap, (XtArgVal)NULL },
  87.       { XtNcallback, (XtArgVal)button_callbacks },
  88. +     { XtNresizable, (XtArgVal) FALSE },
  89.   };
  90.   
  91.   extern int    PANEL_LEFT, PANEL_TOP, PANEL_HEIGHT, PANEL_WID;
  92. ***************
  93. *** 206,212 ****
  94.       XSetForeground(d, cgc, fg);
  95.       XSetBackground(d, cgc, bg);
  96.       
  97. -     /*XCopyGC(d, gc, ~0, cgc);*/
  98.       for (i = 0; i < N_SWITCHES; ++i)
  99.       {
  100.           sw = &switches[i];
  101. --- 213,218 ----
  102. diff -c /tmp/ruler.c ruler.c
  103. *** /tmp/ruler.c    Fri Aug 26 09:38:50 1988
  104. --- ruler.c    Fri Aug 26 08:51:05 1988
  105. ***************
  106. *** 18,28 ****
  107. --- 18,36 ----
  108.   #define            QUARTER_MARK        8
  109.   #define            SIXTEENTH_MARK        6
  110.   
  111. + #ifndef    X11
  112.   #define            MARK_HT            5
  113.   #define            TRM_WID            15
  114.   #define            TRM_HT            8
  115.   #define            SRM_WID            8
  116.   #define            SRM_HT            15
  117. + #else
  118. + #define            MARK_HT            5
  119. + #define            TRM_WID            16
  120. + #define            TRM_HT            8
  121. + #define            SRM_WID            8
  122. + #define            SRM_HT            16
  123. + #endif
  124.   
  125.   extern int        CANVAS_HEIGHT, CANVAS_WIDTH;
  126.   extern int        SIDERULER_WIDTH, SIDERULER_HEIGHT;
  127. ***************
  128. *** 31,37 ****
  129.   extern int        TOPRULER_LEFT, TOPRULER_TOP;
  130.   extern            null_proc();
  131.   extern int        RHS_PANEL;
  132. ! extern int        tracking;
  133.   
  134.   static            lasty = -100;
  135.   static            lastx = -100;
  136. --- 39,45 ----
  137.   extern int        TOPRULER_LEFT, TOPRULER_TOP;
  138.   extern            null_proc();
  139.   extern int        RHS_PANEL;
  140. ! extern int        TRACKING;
  141.   
  142.   static            lasty = -100;
  143.   static            lastx = -100;
  144. ***************
  145. *** 39,44 ****
  146. --- 47,53 ----
  147.   static char        *number[] = {"0", "1", "2", "3", "4", "5", 
  148.                       "6", "7", "8", "9", "10", "11" };
  149.   static int        troffx = -7, troffy = -10;
  150. + #ifndef    X11
  151.   static short        tr_marker_image[8] = {
  152.                   0xFFFE,    /* *************** */
  153.                   0x7FFC,    /*  *************  */
  154. ***************
  155. *** 49,56 ****
  156. --- 58,78 ----
  157.                   0x0380,    /*       ***       */
  158.                   0x0100    /*        *        */
  159.                   };
  160. + #else
  161. + static char        tr_marker_image[16] = {
  162. +                 0xFF, 0xFE,    /* *************** */
  163. +                 0x7F, 0xFC,    /*  *************  */
  164. +                 0x3F, 0xF8,    /*   ***********   */
  165. +                 0x1F, 0xF0,    /*    *********    */
  166. +                 0x0F, 0xE0,    /*     *******     */
  167. +                 0x07, 0xC0,    /*      *****      */
  168. +                 0x03, 0x80,    /*       ***       */
  169. +                 0x01, 0x00    /*        *        */
  170. +                 };
  171. + #endif
  172.   static            mpr_static(trm_pr, TRM_WID, TRM_HT, 1, tr_marker_image);
  173.   static int        srroffx = 2, srroffy = -7;
  174. + #ifndef    X11
  175.   static short        srr_marker_image[15] = {
  176.                   0x0100,    /*          *  */
  177.                   0x0300,    /*         **  */
  178. ***************
  179. *** 68,80 ****
  180.                   0x0300,    /*         **  */
  181.                   0x0100    /*          *  */
  182.                   };
  183. - #ifndef    X11
  184. - static        mpr_static(srrm_pr, SRM_WID, SRM_HT, 1, srr_marker_image);
  185.   #else
  186. ! static        mpr_static(srrm_pr, 16, SRM_HT, 1, srr_marker_image);
  187.   #endif
  188.   
  189.   static int        srloffx = -10, srloffy = -7;
  190.   static short        srl_marker_image[15] = {
  191.                   0x8000,    /*  *          */
  192.                   0xC000,    /*  **         */
  193. --- 90,119 ----
  194.                   0x0300,    /*         **  */
  195.                   0x0100    /*          *  */
  196.                   };
  197.   #else
  198. ! static char        srr_marker_image[16] = {
  199. !                 0x01,    /*          *  */
  200. !                 0x03,    /*         **  */
  201. !                 0x07,    /*        ***  */
  202. !                 0x0F,    /*       ****  */
  203. !                 0x1F,    /*      *****  */
  204. !                 0x3F,    /*     ******  */
  205. !                 0x7F,    /*    *******  */
  206. !                 0xFF,    /*   ********  */
  207. !                 0x7F,    /*    *******  */
  208. !                 0x3F,    /*     ******  */
  209. !                 0x1F,    /*      *****  */
  210. !                 0x0F,    /*       ****  */
  211. !                 0x07,    /*        ***  */
  212. !                 0x03,    /*         **  */
  213. !                 0x01,    /*          *  */
  214. !                 0x00
  215. !                 };
  216.   #endif
  217. + static        mpr_static(srrm_pr, SRM_WID, SRM_HT, 1, srr_marker_image);
  218.   
  219.   static int        srloffx = -10, srloffy = -7;
  220. + #ifndef    X11
  221.   static short        srl_marker_image[15] = {
  222.                   0x8000,    /*  *          */
  223.                   0xC000,    /*  **         */
  224. ***************
  225. *** 92,102 ****
  226.                   0xC000,    /*  **         */
  227.                   0x8000    /*  *          */
  228.                   };
  229. - #ifndef    X11
  230. - static        mpr_static(srlm_pr, SRM_WID, SRM_HT, 1, srl_marker_image);
  231.   #else
  232. ! static        mpr_static(srlm_pr, 16, SRM_HT, 1, srl_marker_image);
  233.   #endif
  234.   
  235.   #ifdef    X11
  236.   static Pixmap        toparrow_pm, sidearrow_pm;
  237. --- 131,157 ----
  238.                   0xC000,    /*  **         */
  239.                   0x8000    /*  *          */
  240.                   };
  241.   #else
  242. ! static char        srl_marker_image[16] = {
  243. !                 0x80,    /*  *          */
  244. !                 0xC0,    /*  **         */
  245. !                 0xE0,    /*  ***        */
  246. !                 0xF0,    /*  ****       */
  247. !                 0xF8,    /*  *****      */
  248. !                 0xFC,    /*  ******     */
  249. !                 0xFE,    /*  *******    */
  250. !                 0xFF,    /*  ********   */
  251. !                 0xFE,    /*  *******    */
  252. !                 0xFC,    /*  ******     */
  253. !                 0xF8,    /*  *****      */
  254. !                 0xF0,    /*  ****       */
  255. !                 0xE0,    /*  ***        */
  256. !                 0xC0,    /*  **         */
  257. !                 0x80,    /*  *          */
  258. !                 0x00
  259. !                 };
  260.   #endif
  261. + static        mpr_static(srlm_pr, SRM_WID, SRM_HT, 1, srl_marker_image);
  262.   
  263.   #ifdef    X11
  264.   static Pixmap        toparrow_pm, sidearrow_pm;
  265. ***************
  266. *** 111,121 ****
  267.       pw_write(topruler_pixwin, x + troffx, RULER_WIDTH + troffy, 
  268.           TRM_WID, TRM_HT, INV_PAINT, &trm_pr, 0, 0);
  269.   #else
  270. !     XCopyArea(tool_d, toparrow_pm, topruler_pixwin, gccache[INV_PAINT],
  271.           0, 0, trm_pr.width, trm_pr.height,
  272. -         lastx + troffx, TOPRULER_HEIGHT + troffy);
  273. -     XCopyArea(tool_d, toparrow_pm, topruler_pixwin, gccache[INV_PAINT],
  274. -         0, 0, trm_pr.width, trm_pr.height,
  275.           x + troffx, TOPRULER_HEIGHT + troffy);
  276.   #endif    X11
  277.       lastx = x;
  278. --- 166,176 ----
  279.       pw_write(topruler_pixwin, x + troffx, RULER_WIDTH + troffy, 
  280.           TRM_WID, TRM_HT, INV_PAINT, &trm_pr, 0, 0);
  281.   #else
  282. !     XClearArea(tool_d, topruler_pixwin,lastx + troffx,
  283. !            TOPRULER_HEIGHT + troffy,trm_pr.width,
  284. !            trm_pr.height, False);
  285. !     XCopyArea(tool_d, toparrow_pm, topruler_pixwin, topgc,
  286.           0, 0, trm_pr.width, trm_pr.height,
  287.           x + troffx, TOPRULER_HEIGHT + troffy);
  288.   #endif    X11
  289.       lastx = x;
  290. ***************
  291. *** 181,186 ****
  292. --- 236,246 ----
  293.       { XtNhorizDistance, (XtArgVal)0 },
  294.       { XtNfromVert, (XtArgVal)NULL },
  295.       { XtNvertDistance, (XtArgVal)0 },
  296. +     { XtNresizable, (XtArgVal)FALSE },
  297. +     { XtNtop, (XtArgVal)XtRubber },
  298. +     { XtNbottom, (XtArgVal)XtRubber },
  299. +     { XtNleft, (XtArgVal)XtRubber },
  300. +     { XtNright, (XtArgVal)XtRubber },
  301.   };
  302.   
  303.   extern int    SIDERULER_WIDTH, SIDERULER_HEIGHT;
  304. ***************
  305. *** 193,203 ****
  306. --- 253,275 ----
  307.       ruler_args[3].value = SIDERULER_HEIGHT = CANVAS_HEIGHT;
  308.       ruler_args[5].value = (XtArgVal)canvas_sw;
  309.       ruler_args[7].value = (XtArgVal)topruler_sw;
  310. +     /* Place the sideruler below the topruler, next to the canvas,
  311. +        but fixed offset from the top of the form */
  312. +     ruler_args[10].value = (XtArgVal)XtChainTop;
  313. +     ruler_args[11].value = (XtArgVal)XtRubber;
  314. +     ruler_args[12].value = (XtArgVal)XtRubber;
  315. +     ruler_args[13].value = (XtArgVal)XtRubber;
  316. +     
  317.       sideruler_sw = XtCreateWidget("sruler", labelWidgetClass, tool,
  318.           ruler_args, XtNumber(ruler_args));
  319.       return(1);
  320.   }
  321.   
  322. + redisplay_sideruler()
  323. + {
  324. +     XClearWindow(tool_d, sideruler_pixwin);
  325. + }
  326. + 
  327.   setup_rulers()
  328.   {
  329.       register int        i, j;
  330. ***************
  331. *** 254,259 ****
  332. --- 326,350 ----
  333.       ruler_args[0].value = (XtArgVal)p;
  334.       XtSetValues(topruler_sw, ruler_args, 1);
  335.   
  336. +     /* The arrows will be XORed into the rulers.
  337. +        We want the foreground color in the arrow to result in
  338. +        the foreground or background color in the display.
  339. +        so if the source pixel is fg^bg, it produces fg when XOR'ed
  340. +        with bg, and bg when XOR'ed with bg.
  341. + 
  342. +        If the source pixel is zero, it produces fg when XOR'ed with
  343. +        fg, and bg when XOR'ed with bg.
  344. +        */
  345. +     XSetForeground(tool_d, gc, fg ^ bg);
  346. +     XSetBackground(tool_d, gc, 0);
  347. + 
  348. +     /* make pixmaps for top ruler arrow */
  349. +     toparrow_pm = XCreatePixmap(tool_d, topruler_pixwin, trm_pr.width,
  350. +                     trm_pr.height,
  351. +                     DefaultDepthOfScreen(tool_s));
  352. +     XPutImage(tool_d, toparrow_pm, gc, &trm_pr, 0, 0, 0, 0,
  353. +         trm_pr.width, trm_pr.height);
  354. +     
  355.       /* side ruler, adjustments for digits are kludges based on 6x13 char */
  356.       p = XCreatePixmap(tool_d, sideruler_pixwin,
  357.                 SIDERULER_WIDTH, SIDERULER_HEIGHT,
  358. ***************
  359. *** 317,329 ****
  360.       ruler_args[0].value = (XtArgVal)p;
  361.       XtSetValues(sideruler_sw, ruler_args, 1);
  362.   
  363. !     /* make pixmaps for ruler arrows */
  364. !     toparrow_pm = XCreatePixmap(tool_d, topruler_pixwin, trm_pr.width,
  365. !                     trm_pr.height,
  366. !                     DefaultDepthOfScreen(tool_s));
  367. !     XPutImage(tool_d, toparrow_pm, gc, &trm_pr, 0, 0, 0, 0,
  368. !         trm_pr.width, trm_pr.height);
  369. !     
  370.       if( RHS_PANEL )
  371.       {
  372.           sidearrow_pm = XCreatePixmap(tool_d, sideruler_pixwin,
  373. --- 408,418 ----
  374.       ruler_args[0].value = (XtArgVal)p;
  375.       XtSetValues(sideruler_sw, ruler_args, 1);
  376.   
  377. !     /* Colors set as above */
  378. !     XSetForeground(tool_d, gc, fg ^ bg);
  379. !     XSetBackground(tool_d, gc, 0);
  380. ! 
  381. !     /* make pixmaps for side ruler arrow */
  382.       if( RHS_PANEL )
  383.       {
  384.           sidearrow_pm = XCreatePixmap(tool_d, sideruler_pixwin,
  385. ***************
  386. *** 434,443 ****
  387. --- 523,545 ----
  388.       ruler_args[2].value = TOPRULER_WIDTH = CANVAS_WIDTH;;
  389.       ruler_args[3].value = TOPRULER_HEIGHT = RULER_WIDTH;
  390.       ruler_args[5].value = (XtArgVal)panel_sw;
  391. +     ruler_args[7].value = (XtArgVal)NULL;
  392. +     /* fix the top & bottom to the top of the form,
  393. +        the left to the panel, and the right is rubber */
  394. +     ruler_args[10].value = (XtArgVal)XtChainTop;
  395. +     ruler_args[11].value = (XtArgVal)XtChainTop;
  396. +     ruler_args[12].value = (XtArgVal)XtRubber;
  397. +     ruler_args[13].value = (XtArgVal)XtRubber;
  398. +     
  399.       topruler_sw = XtCreateWidget("truler", labelWidgetClass, tool,
  400.           ruler_args, XtNumber(ruler_args));
  401.       return(1);
  402.   }
  403. + 
  404. + redisplay_topruler()
  405. + {
  406. +     XClearWindow(tool_d, topruler_pixwin);
  407. + }
  408.   #endif    X11
  409.   
  410.   #ifndef    X11
  411. ***************
  412. *** 479,485 ****
  413.   set_rulermark(x, y)
  414.   int    x, y;
  415.   {
  416. !     if( tracking )
  417.       {
  418.           set_siderulermark(y);
  419.           set_toprulermark(x);
  420. --- 581,587 ----
  421.   set_rulermark(x, y)
  422.   int    x, y;
  423.   {
  424. !     if( TRACKING )
  425.       {
  426.           set_siderulermark(y);
  427.           set_toprulermark(x);
  428. ***************
  429. *** 486,491 ****
  430. --- 588,601 ----
  431.       }
  432.   }
  433.   
  434. + #ifdef    X11
  435. + redisplay_rulers()
  436. + {
  437. +     redisplay_topruler();
  438. +     redisplay_sideruler();
  439. + }
  440. + #endif
  441. + 
  442.   set_siderulermark(y)
  443.   int    y;
  444.   {
  445. ***************
  446. *** 508,528 ****
  447.       lasty = sy;
  448.   #else
  449.       if( RHS_PANEL ) {
  450.           XCopyArea(tool_d, sidearrow_pm, sideruler_pixwin,
  451. !               gccache[INV_PAINT], 0, 0, srlm_pr.width,
  452. !               srlm_pr.height, RULER_WIDTH+srloffx, lasty + srloffy);
  453. !         XCopyArea(tool_d, sidearrow_pm, sideruler_pixwin,
  454. !               gccache[INV_PAINT], 0, 0, srlm_pr.width,
  455.                 srlm_pr.height, RULER_WIDTH+srloffx, y + srloffy);
  456.       }
  457.       else
  458.       {
  459.           XCopyArea(tool_d, sidearrow_pm, sideruler_pixwin,
  460. !               gccache[INV_PAINT], 0, 0, srrm_pr.width,
  461. !               srrm_pr.height, -srroffx, lasty + srroffy);
  462. !         XCopyArea(tool_d, sidearrow_pm, sideruler_pixwin,
  463. !               gccache[INV_PAINT], 0, 0, srrm_pr.width,
  464. !               srrm_pr.height, -srroffx, y + srroffy);
  465.       }
  466.       lasty = y;
  467.   #endif    X11
  468. --- 618,642 ----
  469.       lasty = sy;
  470.   #else
  471.       if( RHS_PANEL ) {
  472. +         /* Because the ruler uses a background pixmap, we can win
  473. +            here by using XClearArea to erase the old thing. */
  474. +         XClearArea(tool_d, sideruler_pixwin,
  475. +                RULER_WIDTH+srloffx, lasty + srloffy,
  476. +                srlm_pr.width, srlm_pr.height, False);
  477.           XCopyArea(tool_d, sidearrow_pm, sideruler_pixwin,
  478. !               sidegc, 0, 0, srlm_pr.width,
  479.                 srlm_pr.height, RULER_WIDTH+srloffx, y + srloffy);
  480.       }
  481.       else
  482.       {
  483. +         /* Because the ruler uses a background pixmap, we can win
  484. +            here by using XClearArea to erase the old thing. */
  485. +         XClearArea(tool_d, sideruler_pixwin,
  486. +                srroffx, lasty + srroffy,
  487. +                srlm_pr.width, srlm_pr.height, False);
  488.           XCopyArea(tool_d, sidearrow_pm, sideruler_pixwin,
  489. !               sidegc, 0, 0, srrm_pr.width,
  490. !               srrm_pr.height, srroffx, y + srroffy);
  491.       }
  492.       lasty = y;
  493.   #endif    X11
  494. diff -c /tmp/main.c main.c
  495. *** /tmp/main.c    Fri Aug 26 09:38:54 1988
  496. --- main.c    Thu Aug 25 11:19:36 1988
  497. ***************
  498. *** 54,65 ****
  499.   extern int        DEBUG;
  500.   extern int        RHS_PANEL;
  501.   extern int        INVERSE;
  502.   
  503.   TOOL            tool;
  504.   int            WINDOW_WIDTH, WINDOW_HEIGHT;
  505.   char            file_header[32] = "#FIG ";
  506.   static char        *file = NULL;
  507. - int            tracking = 1;
  508.   
  509.   get_args(argc, argv)
  510.   int    argc;
  511. --- 54,65 ----
  512.   extern int        DEBUG;
  513.   extern int        RHS_PANEL;
  514.   extern int        INVERSE;
  515. + extern int        TRACKING;
  516.   
  517.   TOOL            tool;
  518.   int            WINDOW_WIDTH, WINDOW_HEIGHT;
  519.   char            file_header[32] = "#FIG ";
  520.   static char        *file = NULL;
  521.   
  522.   get_args(argc, argv)
  523.   int    argc;
  524. ***************
  525. *** 115,125 ****
  526.                    break;
  527.   
  528.                case 't':    /* turn on tracking */
  529. !                  tracking = 1;
  530.                    break;
  531.   
  532.                case 'n':    /* turn off tracking */
  533. !                  tracking = 0;
  534.                    break;
  535.                        
  536.                default:
  537. --- 115,125 ----
  538.                    break;
  539.   
  540.                case 't':    /* turn on tracking */
  541. !                  TRACKING = 1;
  542.                    break;
  543.   
  544.                case 'n':    /* turn off tracking */
  545. !                  TRACKING = 0;
  546.                    break;
  547.                        
  548.                default:
  549. ***************
  550. *** 192,198 ****
  551.       {XtNreverseVideo, XtCReverseVideo, XtRBoolean, sizeof(int),
  552.            (Cardinal)&INVERSE, XtRBoolean, (caddr_t)&false},
  553.       {"trackCursor", "Track", XtRBoolean, sizeof(int),
  554. !          (Cardinal)&tracking, XtRBoolean, (caddr_t)&true},
  555.   };
  556.   
  557.   static XrmOptionDescRec options[] =
  558. --- 192,198 ----
  559.       {XtNreverseVideo, XtCReverseVideo, XtRBoolean, sizeof(int),
  560.            (Cardinal)&INVERSE, XtRBoolean, (caddr_t)&false},
  561.       {"trackCursor", "Track", XtRBoolean, sizeof(int),
  562. !          (Cardinal)&TRACKING, XtRBoolean, (caddr_t)&true},
  563.   };
  564.   
  565.   static XrmOptionDescRec options[] =
  566. ***************
  567. *** 247,252 ****
  568. --- 247,283 ----
  569.       tool_sn = DefaultScreen(tool_d);
  570.       
  571.       gc = DefaultGC(tool_d, tool_sn);
  572. + 
  573. +     if( CellsOfScreen(tool_s) == 2 && INVERSE )
  574. +     {
  575. +         XrmValue    value;
  576. +         XrmDatabase newdb = (XrmDatabase) 0;
  577. +         extern XrmDatabase XtDefaultDB;
  578. + 
  579. +         value.size = sizeof("White");
  580. +         value.addr = "White";
  581. +         XrmPutResource(&newdb, "xfig*borderColor", "String",
  582. +                    &value);
  583. +         value.size = sizeof("White");
  584. +         value.addr = "White";
  585. +         XrmPutResource(&newdb, "xfig*foreground", "String",
  586. +                    &value);
  587. +         value.size = sizeof("Black");
  588. +         value.addr = "Black";
  589. +         XrmPutResource(&newdb, "xfig*background", "String",
  590. +                    &value);
  591. +         XrmMergeDatabases(newdb, &XtDefaultDB);
  592. + 
  593. +         /* now set the tool part, since its already created */
  594. +         XtSetArg(tmp_arg[0], XtNborderColor,
  595. +              WhitePixelOfScreen(tool_s));
  596. +         XtSetArg(tmp_arg[1], XtNforeground,
  597. +              WhitePixelOfScreen(tool_s));
  598. +         XtSetArg(tmp_arg[2], XtNbackground,
  599. +              BlackPixelOfScreen(tool_s));
  600. +         XtSetValues(tool, tmp_arg, 3);
  601. +     }
  602. +     
  603.       init_font();
  604.       init_cursor();
  605.       form = XtCreateManagedWidget("form", formWidgetClass, tool,
  606. ***************
  607. *** 264,270 ****
  608.           CANVAS_HEIGHT = landscape ? DEF_CANVAS_WIDTH :
  609.               DEF_CANVAS_HEIGHT;
  610.       
  611. !     if( CANVAS_HEIGHT < DEF_CANVAS_HEIGHT )
  612.           ICON_COLUMN = ICON_COLUMN_LAND;
  613.           
  614.       (void)init_panel(form);
  615. --- 295,302 ----
  616.           CANVAS_HEIGHT = landscape ? DEF_CANVAS_WIDTH :
  617.               DEF_CANVAS_HEIGHT;
  618.       
  619. !     if( (CANVAS_HEIGHT < DEF_CANVAS_HEIGHT) ||
  620. !        (HeightOfScreen(tool_s) < DEF_CANVAS_HEIGHT) )
  621.           ICON_COLUMN = ICON_COLUMN_LAND;
  622.           
  623.       (void)init_panel(form);
  624. diff -c /tmp/version.h version.h
  625. *** /tmp/version.h    Fri Aug 26 09:38:57 1988
  626. --- version.h    Wed Aug 24 08:30:22 1988
  627. ***************
  628. *** 8,11 ****
  629.   */
  630.   
  631.   #define            FIG_VERSION        "1.4"
  632. ! #define            MINOR_VERSION        ".2"
  633. --- 8,11 ----
  634.   */
  635.   
  636.   #define            FIG_VERSION        "1.4"
  637. ! #define            MINOR_VERSION        ".3"
  638. diff -c /tmp/xfig.1 xfig.1
  639. *** /tmp/xfig.1    Fri Aug 26 09:38:59 1988
  640. --- xfig.1    Thu Aug 25 15:34:19 1988
  641. ***************
  642. *** 263,269 ****
  643.   Create ellipses using the same procedure as for the drawing of circles.
  644.   .TP
  645.   .I GLUE
  646. ! Glue the primitive objects within a bounding box into a compound object
  647.   (the bounding box itself is not part of the figure; 
  648.   it is a visual aid for manipulating the compound). 
  649.   .TP
  650. --- 263,269 ----
  651.   Create ellipses using the same procedure as for the drawing of circles.
  652.   .TP
  653.   .I GLUE
  654. ! Glue the objects within a bounding box into a compound object
  655.   (the bounding box itself is not part of the figure; 
  656.   it is a visual aid for manipulating the compound). 
  657.   .TP
  658. ***************
  659. *** 302,307 ****
  660. --- 302,309 ----
  661.   Only compound objects can be scaled.  Click the left button
  662.   on a corner of the bounding box, stretch the
  663.   bounding box to the desired size, and click the middle button.
  664. + Or click the left button on a side of the bounding box, stretch that
  665. + side to the desired size, and click the middle button.
  666.   .TP
  667.   .I SPLINE
  668.   Create (quadratic spline) spline objects.
  669. ***************
  670. *** 313,319 ****
  671.   .I TEXT
  672.   Create text strings. Click the left button at the desired position on
  673.   the canvas window, then enter text from the keyboard.
  674. ! Terminate by clicking the middle button or typing the return key.
  675.   .TP
  676.   .I TURN
  677.   Turn \fIPOLYGON\fP into a \fICLOSED INTERPOLATED SPLINE\fP object, or
  678. --- 315,325 ----
  679.   .I TEXT
  680.   Create text strings. Click the left button at the desired position on
  681.   the canvas window, then enter text from the keyboard.
  682. ! A DEL or ^H (backspace) will delete a character, while a ^U will kill
  683. ! the entire line.
  684. ! Terminate by clicking the middle button or typing the return key.  To
  685. ! edit text, click on an existing text string with the left button.
  686. ! Insertion of characters will take place at that point.  
  687.   .TP
  688.   .I TURN
  689.   Turn \fIPOLYGON\fP into a \fICLOSED INTERPOLATED SPLINE\fP object, or
  690. ***************
  691. *** 466,484 ****
  692.   .SH ACKNOWLEDGEMENT
  693.   Many thanks goes to Professor Donald E. Fussell who inspired the
  694.   creation of this tool.
  695. ! .SH AUTHOR
  696.   Supoj Sutanthavibul
  697.   .br
  698.   University of Texas at Austin 
  699.   .br
  700. ! (supoj@sally.UTEXAS.EDU) 
  701.   .sp
  702. ! Manual page modified by R. P. C. Rodgers, UCSF School of Pharmacy,
  703.   San Francisco, CA 94118 
  704.   .sp
  705. ! Frank Schmuck of Cornell contributed the LaTeX line drawing modes.
  706.   .sp
  707. ! X11 port by Ken Yap (ken@cs.rochester.edu).
  708.   .sp
  709.   Variable window sizes, cleanup of X11 port, right hand side panel
  710. ! under X11, X11 manual page provided by Dana Chee (dana@bellcore.com).
  711. --- 472,522 ----
  712.   .SH ACKNOWLEDGEMENT
  713.   Many thanks goes to Professor Donald E. Fussell who inspired the
  714.   creation of this tool.
  715. ! .SH AUTHORS
  716. ! Original author:
  717. ! .br
  718.   Supoj Sutanthavibul
  719.   .br
  720.   University of Texas at Austin 
  721.   .br
  722. ! (supoj@sally.utexas.edu) 
  723.   .sp
  724. ! Manual page modified by:
  725. ! .br
  726. ! R. P. C. Rodgers
  727. ! .br
  728. ! UCSF School of Pharmacy
  729. ! .br
  730.   San Francisco, CA 94118 
  731.   .sp
  732. ! The LaTeX line drawing modes were contributed by:
  733. ! .br
  734. ! Frank Schmuck
  735. ! .br
  736. ! Cornell University
  737.   .sp
  738. ! X11 port by:
  739. ! .br
  740. ! Ken Yap
  741. ! .br
  742. ! Rochester
  743. ! .br
  744. ! (ken@cs.rochester.edu)
  745.   .sp
  746.   Variable window sizes, cleanup of X11 port, right hand side panel
  747. ! under X11, X11 manual page provided by:
  748. ! .br
  749. ! Dana Chee
  750. ! .br
  751. ! Bellcore
  752. ! .br
  753. ! (dana@bellcore.com)
  754. ! .sp
  755. ! Cleanup of color port to X11 by:
  756. ! .br
  757. ! John T. Kohl
  758. ! .br
  759. ! MIT
  760. ! .br
  761. ! (jtkohl@athena.mit.edu)
  762. ! 
  763. diff -c /tmp/scale.c scale.c
  764. *** /tmp/scale.c    Fri Aug 26 09:39:02 1988
  765. --- scale.c    Thu Aug 25 15:51:04 1988
  766. ***************
  767. *** 21,27 ****
  768.   extern int        fix_x, fix_y, cur_x, cur_y;
  769.   extern F_pos        last_position, new_position;  /* used in undo */
  770.   
  771. ! extern F_compound    *compound_point_search();
  772.   extern            (*canvas_kbd_proc)();
  773.   extern            (*canvas_locmove_proc)();
  774.   extern            (*canvas_leftbut_proc)();
  775. --- 21,27 ----
  776.   extern int        fix_x, fix_y, cur_x, cur_y;
  777.   extern F_pos        last_position, new_position;  /* used in undo */
  778.   
  779. ! extern F_compound    *compound_point_search(), *compound_search();
  780.   extern            (*canvas_kbd_proc)();
  781.   extern            (*canvas_locmove_proc)();
  782.   extern            (*canvas_leftbut_proc)();
  783. ***************
  784. *** 32,41 ****
  785.   
  786.               prescale_compound(), elastic_compoundbox();
  787.   
  788.   static F_compound    *compound;
  789.   static double        cosa, sina;
  790.   static int        fromx, fromy;
  791. - 
  792.               init_scale_compound();
  793.   
  794.   scale_compound_selected()
  795. --- 32,42 ----
  796.   
  797.               prescale_compound(), elastic_compoundbox();
  798.   
  799. + static enum        {WEST, NORTH, EAST, SOUTH, CORNER} side;
  800. + static int        save_coord;
  801.   static F_compound    *compound;
  802.   static double        cosa, sina;
  803.   static int        fromx, fromy;
  804.               init_scale_compound();
  805.   
  806.   scale_compound_selected()
  807. ***************
  808. *** 53,89 ****
  809.   int    x, y;
  810.   {
  811.       double    dx, dy, l;
  812. ! 
  813. !     if ((compound = compound_point_search(x, y, TOLERANCE, &cur_x, &cur_y)) 
  814. !         == NULL) {
  815. !         return;
  816. !         }
  817. !     if (compound->nwcorner.x == cur_x) 
  818. !         fix_x = compound->secorner.x;
  819. !     else
  820. !         fix_x = compound->nwcorner.x;
  821. !     if (compound->nwcorner.y == cur_y) 
  822. !         fix_y = compound->secorner.y;
  823. !     else
  824. !         fix_y = compound->nwcorner.y;
  825. ! 
  826. !     dx = cur_x - fix_x;  dy = cur_y - fix_y;
  827. !     l = sqrt(dx*dx + dy*dy);
  828. !     cosa = fabs(dx / l);  sina = fabs(dy / l);
  829. ! 
  830. !     fromx = cur_x;  fromy = cur_y;
  831. !     win_setmouseposition(canvas_swfd, cur_x, cur_y);
  832. !     draw_compoundbox(compound, INV_PAINT);
  833. !     draw_rectbox(fix_x, fix_y, cur_x, cur_y, INV_PAINT);
  834. !     set_latestcompound(compound);
  835. !     canvas_locmove_proc = elastic_compoundbox;
  836. !     canvas_middlebut_proc = prescale_compound;
  837. !     canvas_leftbut_proc = canvas_rightbut_proc = null_proc;
  838. !     set_action_on();
  839. !     set_temp_cursor(&null_cursor);
  840. !     win_setmouseposition(canvas_swfd, x, y);
  841.       }
  842.   
  843.   elastic_compoundbox(x, y)
  844.   int    x, y;
  845.   {
  846. --- 54,149 ----
  847.   int    x, y;
  848.   {
  849.       double    dx, dy, l;
  850. !     
  851. !     if ((compound = compound_point_search(x, y, TOLERANCE, &cur_x,
  852. !                           &cur_y)) != NULL)
  853. !     {
  854. !         if (compound->nwcorner.x == cur_x) 
  855. !             fix_x = compound->secorner.x;
  856. !         else
  857. !             fix_x = compound->nwcorner.x;
  858. !         if (compound->nwcorner.y == cur_y) 
  859. !             fix_y = compound->secorner.y;
  860. !         else
  861. !             fix_y = compound->nwcorner.y;
  862. !         
  863. !         side = CORNER;
  864. !         dx = cur_x - fix_x;  dy = cur_y - fix_y;
  865. !         l = sqrt(dx*dx + dy*dy);
  866. !         cosa = fabs(dx / l);  sina = fabs(dy / l);
  867. !         
  868. !         fromx = cur_x;  fromy = cur_y;
  869. !         win_setmouseposition(canvas_swfd, cur_x, cur_y);
  870. !         draw_compoundbox(compound, INV_PAINT);
  871. !         draw_rectbox(fix_x, fix_y, cur_x, cur_y, INV_PAINT);
  872. !         set_latestcompound(compound);
  873. !         canvas_locmove_proc = elastic_compoundbox;
  874. !         canvas_middlebut_proc = prescale_compound;
  875. !         canvas_leftbut_proc = canvas_rightbut_proc = null_proc;
  876. !         set_action_on();
  877. !         set_temp_cursor(&null_cursor);
  878. !         win_setmouseposition(canvas_swfd, x, y);
  879.       }
  880. +     else if ((compound = compound_search(x, y, TOLERANCE, &cur_x, &cur_y))
  881. +          != NULL )
  882. +     {
  883. +         /* figure out which side the cursor is close to. */
  884. +         if (compound->nwcorner.x == cur_x)
  885. +             side = WEST;
  886. +         else if (compound->nwcorner.y == cur_y)
  887. +             side = NORTH;
  888. +         else if (compound->secorner.x == cur_x)
  889. +             side = EAST;
  890. +         else if (compound->secorner.y == cur_y)
  891. +             side = SOUTH;
  892. +         else
  893. +             return;
  894. +         
  895. +         /* figure out a fixed point of the compound for scaling */
  896. +         switch (side) {
  897. +         case WEST:
  898. +         case NORTH:
  899. +             fix_x = compound->secorner.x;
  900. +             fix_y = compound->secorner.y;
  901. +             cur_x = compound->nwcorner.x;
  902. +             cur_y = compound->nwcorner.y;
  903. +             break;
  904. +         case EAST:
  905. +         case SOUTH:
  906. +             fix_x = compound->nwcorner.x;
  907. +             fix_y = compound->nwcorner.y;
  908. +             cur_x = compound->secorner.x;
  909. +             cur_y = compound->secorner.y;
  910. +             break;
  911. +         }
  912. +         
  913. +         /* save initial corner position */
  914. +         fromx = cur_x;  fromy = cur_y;
  915. +         /* save x or y coordinate for restoring the cursor */
  916. +         /* at the end of the scaling */
  917. +         switch (side) {
  918. +         case NORTH: case SOUTH:
  919. +             save_coord = x;
  920. +             break;
  921. +         case EAST: case WEST:
  922. +             save_coord = y;
  923. +             break;
  924. +         }
  925. +         /*  erase the compound box. */
  926. +         win_setmouseposition(canvas_swfd, cur_x, cur_y);
  927. +         draw_compoundbox(compound, INV_PAINT);
  928. +         draw_rectbox(fix_x, fix_y, cur_x, cur_y, INV_PAINT);
  929. +         set_latestcompound(compound);
  930. +         canvas_locmove_proc = elastic_compoundbox;
  931. +         canvas_middlebut_proc = prescale_compound;
  932. +         canvas_leftbut_proc = canvas_rightbut_proc = null_proc;
  933. +         set_action_on();
  934. +         set_temp_cursor(&null_cursor);
  935. +         win_setmouseposition(canvas_swfd, x, y);
  936. +     }
  937. + }
  938.   
  939. + 
  940.   elastic_compoundbox(x, y)
  941.   int    x, y;
  942.   {
  943. ***************
  944. *** 98,115 ****
  945.   {
  946.       double    xx, yy, d;
  947.   
  948. !     xx = x - fix_x;
  949. !     yy = y - fix_y;
  950. !     d = sqrt(xx*xx + yy*yy);
  951. !     if (xx < 0)
  952. !         cur_x = fix_x - round(d * cosa);
  953. !     else
  954. !         cur_x = fix_x + round(d * cosa);
  955. !     if (yy < 0)
  956. !         cur_y = fix_y - round(d * sina);
  957. !     else
  958. !         cur_y = fix_y + round(d * sina);
  959.       }
  960.   
  961.   prescale_compound(x, y)
  962.   int    x, y;
  963. --- 158,187 ----
  964.   {
  965.       double    xx, yy, d;
  966.   
  967. !     switch(side) {
  968. !     case CORNER:
  969. !         xx = x - fix_x;
  970. !         yy = y - fix_y;
  971. !         d = sqrt(xx*xx + yy*yy);
  972. !         if (xx < 0)
  973. !             cur_x = fix_x - round(d * cosa);
  974. !         else
  975. !             cur_x = fix_x + round(d * cosa);
  976. !         if (yy < 0)
  977. !             cur_y = fix_y - round(d * sina);
  978. !         else
  979. !             cur_y = fix_y + round(d * sina);
  980. !         break;
  981. !     case NORTH:
  982. !     case SOUTH:
  983. !         cur_y = y;
  984. !         break;
  985. !     case EAST:
  986. !     case WEST:
  987. !         cur_x = x;
  988. !         break;
  989.       }
  990. + }
  991.   
  992.   prescale_compound(x, y)
  993.   int    x, y;
  994. ***************
  995. *** 130,135 ****
  996. --- 202,218 ----
  997.       last_position.y = fromy;
  998.       new_position.x = cur_x;
  999.       new_position.y = cur_y;
  1000. +     /* update cursor position for single axis scaling. */
  1001. +     switch (side) {
  1002. +     case NORTH: case SOUTH:
  1003. +         /* maintain old horiz. pos. */
  1004. +         cur_x = save_coord;
  1005. +         break;
  1006. +     case EAST: case WEST:
  1007. +         /* maintain old vert. pos. */
  1008. +         cur_y = save_coord;
  1009. +         break;
  1010. +     }
  1011.       clean_up();
  1012.       set_action_object(F_SCALE, O_COMPOUND);
  1013.       set_latestcompound(compound);
  1014. ***************
  1015. *** 147,152 ****
  1016. --- 230,236 ----
  1017.       F_ellipse    *e;
  1018.       F_text        *t;
  1019.       F_arc        *a;
  1020. +     F_compound    *c1;
  1021.       int        x1, y1, x2, y2;
  1022.   
  1023.       x1 = round(refx + (c->nwcorner.x - refx) * sx);
  1024. ***************
  1025. *** 172,177 ****
  1026. --- 256,264 ----
  1027.           }
  1028.       for (t = c->texts; t != NULL; t = t->next) {
  1029.           scale_text(t, sx, sy, refx, refy);
  1030. +         }
  1031. +     for (c1 = c->compounds; c1 != NULL; c1 = c1->next) {
  1032. +         scale_compound(c1, sx, sy, refx, refy);
  1033.           }
  1034.       }
  1035.   
  1036. diff -c /tmp/canvas.c canvas.c
  1037. *** /tmp/canvas.c    Fri Aug 26 09:39:05 1988
  1038. --- canvas.c    Fri Aug 26 08:51:04 1988
  1039. ***************
  1040. *** 150,155 ****
  1041. --- 150,156 ----
  1042.       { XtNhorizDistance, (XtArgVal)0 },
  1043.       { XtNfromVert, (XtArgVal)NULL },
  1044.       { XtNvertDistance, (XtArgVal)0 },
  1045. +     { XtNtop, (XtArgVal)XtChainTop },
  1046.   };
  1047.   
  1048.   static void canvas_exposed(tool, event, params, nparams)
  1049. ***************
  1050. *** 161,166 ****
  1051. --- 162,168 ----
  1052.       if (((XExposeEvent *)event)->count > 0)
  1053.           return;
  1054.       redisplay_canvas();
  1055. +     redisplay_rulers();
  1056.   }
  1057.   
  1058.   static void set_pos(tool, event, params, nparams)
  1059. ***************
  1060. *** 193,201 ****
  1061. --- 195,210 ----
  1062.       <Key>:Event()\n\
  1063.       <Expose>:Expose()\n";
  1064.   
  1065. + static    Arg    canvas_color_args[] = {
  1066. +     { XtNforeground, (XtArgVal) &x_fg_color.pixel },
  1067. +     { XtNbackground, (XtArgVal) &x_bg_color.pixel },
  1068. + };
  1069. + 
  1070.   int init_canvas(tool)
  1071.       TOOL        tool;
  1072.   {
  1073. +     XColor    fixcolors[2];
  1074. +     
  1075.       canvas_args[3].value = CANVAS_WIDTH;
  1076.       canvas_args[4].value = CANVAS_HEIGHT;
  1077.       canvas_args[5].value = (XtArgVal)panel_sw;
  1078. ***************
  1079. *** 202,207 ****
  1080. --- 211,233 ----
  1081.       canvas_args[7].value = (XtArgVal)topruler_sw;
  1082.       canvas_sw = XtCreateWidget("canvas", labelWidgetClass, tool,
  1083.           canvas_args, XtNumber(canvas_args));
  1084. +     XtGetValues(canvas_sw, canvas_color_args, XtNumber(canvas_color_args));
  1085. + 
  1086. +     /* get the RGB values for recolor cursor use -- may want to have
  1087. +        cursor color resource */
  1088. +     fixcolors[0] = x_fg_color;
  1089. +     fixcolors[1] = x_bg_color;
  1090. +     XQueryColors(tool_d, DefaultColormapOfScreen(tool_s), fixcolors, 2);
  1091. +     x_fg_color = fixcolors[0];
  1092. +     x_bg_color = fixcolors[1];
  1093. +     
  1094. +     /* now fix the global GC */
  1095. +     XSetState(tool_d, gc, x_fg_color.pixel, x_bg_color.pixel, GXcopy,
  1096. +           AllPlanes);
  1097. +     
  1098. +     /* and recolor the cursors */
  1099. +     recolor_cursors();
  1100. +     
  1101.       canvas_leftbut_proc = null_proc;
  1102.       canvas_middlebut_proc = null_proc;
  1103.       canvas_rightbut_proc = null_proc;
  1104. ***************
  1105. *** 240,245 ****
  1106. --- 266,286 ----
  1107.       switch (event->type)
  1108.       {
  1109.       case MotionNotify:
  1110. +         {
  1111. +             Window rw, cw;
  1112. +             static int sx = -10000, sy = -10000;
  1113. +             int rx, ry, cx, cy;
  1114. +             unsigned int mask;
  1115. + 
  1116. +             XQueryPointer(event->display, event->window,
  1117. +                       &rw, &cw,
  1118. +                       &rx, &ry,
  1119. +                       &cx, &cy,
  1120. +                       &mask);
  1121. +             if(cx == sx && cy == sy) break;
  1122. +             x = sx = cx;
  1123. +             y = sy = cy;
  1124. +         }
  1125.           set_rulermark(x, y);
  1126.           (*canvas_locmove_proc)(x, y);
  1127.           break;
  1128. diff -c /tmp/cursor.c cursor.c
  1129. *** /tmp/cursor.c    Fri Aug 26 09:39:07 1988
  1130. --- cursor.c    Wed Aug 24 15:37:56 1988
  1131. ***************
  1132. *** 106,109 ****
  1133. --- 106,128 ----
  1134.       vbar_cursor.bitmap = (XImage *)XCreateFontCursor(d, XC_xterm);
  1135.       wait_cursor.bitmap = (XImage *)XCreateFontCursor(d, XC_watch);
  1136.   }
  1137. + recolor_cursors()
  1138. + {
  1139. +     register Display  *d = tool_d;
  1140. +     
  1141. +     XRecolorCursor(d, (Cursor)arrow_cursor.bitmap, &x_fg_color, &x_bg_color);
  1142. +     XRecolorCursor(d, (Cursor)bull_cursor.bitmap, &x_fg_color, &x_bg_color);
  1143. +     XRecolorCursor(d, (Cursor)buster_cursor.bitmap, &x_fg_color, &x_bg_color);
  1144. +     XRecolorCursor(d, (Cursor)char_cursor.bitmap, &x_fg_color, &x_bg_color);
  1145. +     XRecolorCursor(d, (Cursor)crosshair_cursor.bitmap, &x_fg_color,
  1146. +                &x_bg_color);
  1147. +     XRecolorCursor(d, (Cursor)null_cursor.bitmap, &x_fg_color, &x_bg_color);
  1148. +     XRecolorCursor(d, (Cursor)magnifier_cursor.bitmap, &x_fg_color,
  1149. +                &x_bg_color);
  1150. +     XRecolorCursor(d, (Cursor)pencil_cursor.bitmap, &x_fg_color, &x_bg_color);
  1151. +     XRecolorCursor(d, (Cursor)pick15_cursor.bitmap, &x_fg_color, &x_bg_color);
  1152. +     XRecolorCursor(d, (Cursor)pick9_cursor.bitmap, &x_fg_color, &x_bg_color);
  1153. +     XRecolorCursor(d, (Cursor)vbar_cursor.bitmap, &x_fg_color, &x_bg_color);
  1154. +     XRecolorCursor(d, (Cursor)wait_cursor.bitmap, &x_fg_color, &x_bg_color);
  1155. + }
  1156.   #endif    X11
  1157. diff -c /tmp/xtra.c xtra.c
  1158. *** /tmp/xtra.c    Fri Aug 26 09:39:09 1988
  1159. --- xtra.c    Fri Aug 26 08:51:07 1988
  1160. ***************
  1161. *** 12,17 ****
  1162. --- 12,24 ----
  1163.   #include "paintop.h"
  1164.   #include "font.h"
  1165.   
  1166. + #define    CTRL_H    8
  1167. + #define    NL    10
  1168. + #define    CR    13
  1169. + #define    CTRL_U    21
  1170. + #define    CTRL_X    24
  1171. + #define    DEL    127
  1172. + 
  1173.   pr_size pf_textwidth(n, f, s)
  1174.       int        n;
  1175.       XFontStruct    *f;
  1176. ***************
  1177. *** 27,50 ****
  1178.       return (ret);
  1179.   }
  1180.   
  1181. ! static GC makegc(op)
  1182.   {
  1183.       register GC    ngc;
  1184.       XGCValues    gcv;
  1185.   
  1186. !     ngc = XCreateGC(tool_d, XtWindow(canvas_sw), 0, &gcv);
  1187. !     XCopyGC(tool_d, gc, ~0, ngc);
  1188. !     XSetFunction(tool_d, ngc, op);
  1189. !     XSetFont(tool_d, ngc, roman_font->fid);
  1190.       return (ngc);
  1191.   }
  1192.   
  1193.   init_gc()
  1194.   {
  1195. !     gccache[PAINT] = makegc(PAINT);
  1196. !     gccache[ERASE] = makegc(ERASE);
  1197. !     gccache[INV_PAINT] = makegc(INV_PAINT);
  1198. !     gccache[MERGE] = makegc(MERGE);
  1199.   }
  1200.   
  1201.   /*
  1202. --- 34,110 ----
  1203.       return (ret);
  1204.   }
  1205.   
  1206. ! static GC makegc(op, fg, bg)
  1207. ! int    op;
  1208. ! Pixel    fg;
  1209. ! Pixel    bg;
  1210.   {
  1211.       register GC    ngc;
  1212.       XGCValues    gcv;
  1213. +     int        gcmask;
  1214.   
  1215. !     gcv.font = roman_font->fid;
  1216. !     gcmask = GCFunction|GCForeground|GCBackground|GCFont;
  1217. !     switch (op) {
  1218. !     case PAINT:
  1219. !         gcv.foreground = fg;
  1220. !         gcv.background = bg;
  1221. !         gcv.function = GXcopy;
  1222. !         break;
  1223. !     case ERASE:
  1224. !         gcv.foreground = bg;
  1225. !         gcv.background = bg;
  1226. !         gcv.function = GXcopy;
  1227. !         break;
  1228. !     case INV_PAINT:
  1229. !         gcv.foreground = fg ^ bg;
  1230. !         gcv.background = bg;
  1231. !         gcv.function = GXxor;
  1232. !         break;
  1233. !     case MERGE:
  1234. !         gcv.foreground = fg;
  1235. !         gcv.background = bg;
  1236. !         gcv.function = GXor;
  1237. !         break;
  1238. !     }
  1239. !     
  1240. !     ngc = XCreateGC(tool_d, XtWindow(canvas_sw), gcmask, &gcv);
  1241. !     XCopyGC(tool_d, gc, ~(gcmask), ngc);
  1242.       return (ngc);
  1243.   }
  1244.   
  1245. + static GC    msg_gccache[0x10];
  1246. + 
  1247.   init_gc()
  1248.   {
  1249. !     Pixel    bg, fg;
  1250. !     Arg    tmp_arg[2];
  1251. !     
  1252. !     gccache[PAINT] = makegc(PAINT, x_fg_color.pixel, x_bg_color.pixel);
  1253. !     gccache[ERASE] = makegc(ERASE, x_fg_color.pixel, x_bg_color.pixel);
  1254. !     gccache[INV_PAINT] = makegc(INV_PAINT, x_fg_color.pixel,
  1255. !                     x_bg_color.pixel);
  1256. !     gccache[MERGE] = makegc(MERGE, x_fg_color.pixel, x_bg_color.pixel);
  1257. ! 
  1258. !     /* Need to get the values so we can make GC's which XOR correctly */
  1259. !     XtSetArg(tmp_arg[0], XtNforeground, &fg);
  1260. !     XtSetArg(tmp_arg[1], XtNbackground, &bg);
  1261. !     XtGetValues(msg_sw, tmp_arg, 2);
  1262. ! 
  1263. !     msg_gccache[PAINT] = makegc(PAINT, fg, bg);
  1264. !     msg_gccache[ERASE] = makegc(ERASE, fg, bg);
  1265. !     
  1266. !     XtSetArg(tmp_arg[0], XtNforeground, &fg);
  1267. !     XtSetArg(tmp_arg[1], XtNbackground, &bg);
  1268. !     XtGetValues(topruler_sw, tmp_arg, 2);
  1269. ! 
  1270. !     topgc = makegc(INV_PAINT, fg, bg);
  1271. !     
  1272. !     XtSetArg(tmp_arg[0], XtNforeground, &fg);
  1273. !     XtSetArg(tmp_arg[1], XtNbackground, &bg);
  1274. !     XtGetValues(sideruler_sw, tmp_arg, 2);
  1275. !     
  1276. !     sidegc = makegc(INV_PAINT, fg, bg);
  1277.   }
  1278.   
  1279.   /*
  1280. ***************
  1281. *** 117,127 ****
  1282.       XWindowAttributes    attr;
  1283.   
  1284.       XClearArea(tool_d, msgswfd, 0, 0, 0, 0, False);
  1285. !     /* uses knowledge that gccache[PAINT] uses roman_font - tsk */
  1286.       len = strlen(prompt);
  1287.       width = char_width(roman_font);
  1288.       y = char_height(roman_font) + 2;
  1289. !     XDrawString(tool_d, msgswfd, gccache[PAINT], 2, y, prompt, len);
  1290.       x = width * len + 4;
  1291.       XGetWindowAttributes(tool_d, msgswfd, &attr);
  1292.       XSelectInput(tool_d, msgswfd, attr.your_event_mask | KeyPressMask);
  1293. --- 177,187 ----
  1294.       XWindowAttributes    attr;
  1295.   
  1296.       XClearArea(tool_d, msgswfd, 0, 0, 0, 0, False);
  1297. !     /* uses knowledge that msg_gccache[PAINT] uses roman_font - tsk */
  1298.       len = strlen(prompt);
  1299.       width = char_width(roman_font);
  1300.       y = char_height(roman_font) + 2;
  1301. !     XDrawString(tool_d, msgswfd, msg_gccache[PAINT], 2, y, prompt, len);
  1302.       x = width * len + 4;
  1303.       XGetWindowAttributes(tool_d, msgswfd, &attr);
  1304.       XSelectInput(tool_d, msgswfd, attr.your_event_mask | KeyPressMask);
  1305. ***************
  1306. *** 134,161 ****
  1307.               continue;
  1308.           switch (buf[0])
  1309.           {
  1310. !         case '\b':
  1311. !         case '\0177':
  1312.               if (r != reply)
  1313.               {
  1314.                   x -= width;
  1315.                   --r;
  1316. !                 XDrawString(tool_d, msgswfd, gccache[ERASE],
  1317.                       x, y, r, 1);
  1318.               }
  1319.               break;
  1320. !         case 'U' & 0x1f:
  1321. !         case 'X' & 0x1f:
  1322.               while (r != reply)
  1323.               {
  1324.                   x -= width;
  1325.                   --r;
  1326. !                 XDrawString(tool_d, msgswfd, gccache[ERASE],
  1327.                       x, y, r, 1);
  1328.               }
  1329.               break;
  1330. !         case '\n':
  1331. !         case '\r':
  1332.               *r = '\0';
  1333.               XClearArea(tool_d, msgswfd, 0, 0, 0, 0, False);
  1334.               return;
  1335. --- 194,221 ----
  1336.               continue;
  1337.           switch (buf[0])
  1338.           {
  1339. !         case CTRL_H:
  1340. !         case DEL:
  1341.               if (r != reply)
  1342.               {
  1343.                   x -= width;
  1344.                   --r;
  1345. !                 XDrawString(tool_d, msgswfd, msg_gccache[ERASE],
  1346.                       x, y, r, 1);
  1347.               }
  1348.               break;
  1349. !         case CTRL_U:
  1350. !         case CTRL_X:
  1351.               while (r != reply)
  1352.               {
  1353.                   x -= width;
  1354.                   --r;
  1355. !                 XDrawString(tool_d, msgswfd, msg_gccache[ERASE],
  1356.                       x, y, r, 1);
  1357.               }
  1358.               break;
  1359. !         case CR:
  1360. !         case NL:
  1361.               *r = '\0';
  1362.               XClearArea(tool_d, msgswfd, 0, 0, 0, 0, False);
  1363.               return;
  1364. ***************
  1365. *** 162,168 ****
  1366.           default:
  1367.               if (buf[0] < ' ' || buf[0] > '~')
  1368.                   continue;
  1369. !             XDrawString(tool_d, msgswfd, gccache[PAINT],
  1370.                   x, y, buf, 1);
  1371.               x += width;
  1372.               *r++ = buf[0];
  1373. --- 222,228 ----
  1374.           default:
  1375.               if (buf[0] < ' ' || buf[0] > '~')
  1376.                   continue;
  1377. !             XDrawString(tool_d, msgswfd, msg_gccache[PAINT],
  1378.                   x, y, buf, 1);
  1379.               x += width;
  1380.               *r++ = buf[0];
  1381. diff -c /tmp/glue.c glue.c
  1382. *** /tmp/glue.c    Fri Aug 26 09:39:11 1988
  1383. --- glue.c    Thu Aug 25 12:08:44 1988
  1384. ***************
  1385. *** 106,111 ****
  1386. --- 106,113 ----
  1387.           c->secorner.x, c->secorner.y);
  1388.       get_arc(&c->arcs, c->nwcorner.x, c->nwcorner.y,
  1389.           c->secorner.x, c->secorner.y);
  1390. +     get_compound(&c->compounds, c->nwcorner.x, c->nwcorner.y,
  1391. +              c->secorner.x, c->secorner.y);
  1392.       /*  get rid of point-marker  */
  1393.       if (pointmarker_shown) toggle_compoundpointmarker(c);
  1394.       if (c->ellipses != NULL) return(1);
  1395. ***************
  1396. *** 113,118 ****
  1397. --- 115,121 ----
  1398.       if (c->lines != NULL) return(1);
  1399.       if (c->texts != NULL) return(1);
  1400.       if (c->arcs != NULL) return(1);
  1401. +     if (c->compounds != NULL) return(1);
  1402.       return(0);
  1403.       }
  1404.   
  1405. ***************
  1406. *** 269,274 ****
  1407. --- 272,318 ----
  1408.           }
  1409.       }
  1410.   
  1411. + get_compound(list, xmin, ymin, xmax, ymax)
  1412. + F_compound    **list;
  1413. + int    xmin, ymin, xmax, ymax;
  1414. + {
  1415. +     F_compound    *compd, *c, *cc;
  1416. +     for (c = objects.compounds; c != NULL;)
  1417. +     {
  1418. +         if (xmin > c->nwcorner.x)
  1419. +         {
  1420. +             cc = c;
  1421. +             c = c->next;
  1422. +             continue;
  1423. +         }
  1424. +         if (xmax < c->secorner.x)
  1425. +         {
  1426. +             cc = c;
  1427. +             c = c->next;
  1428. +             continue;
  1429. +         }
  1430. +         if (ymin > c->nwcorner.y)
  1431. +         {
  1432. +             cc = c;
  1433. +             c = c->next;
  1434. +             continue;
  1435. +         }
  1436. +         if (ymax < c->secorner.y)
  1437. +         {
  1438. +             cc = c;
  1439. +             c = c->next;
  1440. +             continue;
  1441. +         }
  1442. +         compd = c;
  1443. +         if (c == objects.compounds) 
  1444. +             c = objects.compounds = objects.compounds->next;
  1445. +         else
  1446. +             c = cc->next = c->next;
  1447. +         compd->next = *list;
  1448. +         *list = compd;
  1449. +     }
  1450. + }
  1451. + 
  1452.   F_compound *
  1453.   compound_point_search(x, y, tol, px, py)
  1454.   int    x, y, tol, *px, *py;
  1455. ***************
  1456. *** 308,314 ****
  1457.   F_compound    *c;
  1458.   {
  1459.       draw_compoundelements(c, foreground_color, foreground_color,
  1460. !                 PAINT, PAINT, PAINT);
  1461.       }
  1462.   
  1463.   erase_compound(c)
  1464. --- 352,358 ----
  1465.   F_compound    *c;
  1466.   {
  1467.       draw_compoundelements(c, foreground_color, foreground_color,
  1468. !                 PAINT, PAINT, PAINT, PAINT);
  1469.       }
  1470.   
  1471.   erase_compound(c)
  1472. ***************
  1473. *** 315,326 ****
  1474.   F_compound    *c;
  1475.   {
  1476.       draw_compoundelements(c, background_color, background_color,
  1477. !                 ERASE, ERASE, INV_PAINT);
  1478.       }
  1479.   
  1480. ! draw_compoundelements(c, arcop, ellipseop, lineop, splineop, textop)
  1481.   F_compound    *c;
  1482. ! int        arcop, ellipseop, lineop, splineop, textop;
  1483.   {
  1484.       F_line        *l;
  1485.       F_spline    *s;
  1486. --- 359,370 ----
  1487.   F_compound    *c;
  1488.   {
  1489.       draw_compoundelements(c, background_color, background_color,
  1490. !                 ERASE, ERASE, INV_PAINT, ERASE);
  1491.       }
  1492.   
  1493. ! draw_compoundelements(c, arcop, ellipseop, lineop, splineop, textop, compop)
  1494.   F_compound    *c;
  1495. ! int        arcop, ellipseop, lineop, splineop, textop, compop;
  1496.   {
  1497.       F_line        *l;
  1498.       F_spline    *s;
  1499. ***************
  1500. *** 327,333 ****
  1501.       F_ellipse    *e;
  1502.       F_text        *t;
  1503.       F_arc        *a;
  1504. ! 
  1505.       pw_batch_on(canvas_pixwin);
  1506.       for (l = c->lines; l != NULL; l = l->next) {
  1507.           draw_line(l, lineop);
  1508. --- 371,378 ----
  1509.       F_ellipse    *e;
  1510.       F_text        *t;
  1511.       F_arc        *a;
  1512. !     F_compound    *c1;
  1513. !     
  1514.       pw_batch_on(canvas_pixwin);
  1515.       for (l = c->lines; l != NULL; l = l->next) {
  1516.           draw_line(l, lineop);
  1517. ***************
  1518. *** 344,349 ****
  1519. --- 389,398 ----
  1520.       for (t = c->texts; t != NULL; t = t->next) {
  1521.           draw_text(t, textop);
  1522.           }
  1523. +     for (c1 = c->compounds; c1 != NULL; c1 = c1->next) {
  1524. +         draw_compoundbox(c1, INV_PAINT);
  1525. +         compop == ERASE ? erase_compound(c1) : draw_compound(c1);
  1526. +         }
  1527.       pw_batch_off(canvas_pixwin);
  1528.       }
  1529.   
  1530. ***************
  1531. *** 414,416 ****
  1532. --- 463,468 ----
  1533.       for (c = objects.compounds; c != NULL; c = c->next) 
  1534.           draw_compoundbox(c, INV_PAINT);
  1535.       }
  1536. + 
  1537. + 
  1538. + 
  1539. diff -c /tmp/resources.h resources.h
  1540. *** /tmp/resources.h    Fri Aug 26 09:39:14 1988
  1541. --- resources.h    Thu Aug 25 13:27:17 1988
  1542. ***************
  1543. *** 146,152 ****
  1544.   EXTERN Display        *tool_d;
  1545.   EXTERN Screen        *tool_s;
  1546.   EXTERN int        tool_sn;
  1547. ! EXTERN GC        gc, gccache[0x10];
  1548.   
  1549.   struct icon {
  1550.       short         ic_width, ic_height;    /* overall icon dimensions */
  1551. --- 146,153 ----
  1552.   EXTERN Display        *tool_d;
  1553.   EXTERN Screen        *tool_s;
  1554.   EXTERN int        tool_sn;
  1555. ! EXTERN GC        gc, gccache[0x10], topgc, sidegc;
  1556. ! EXTERN XColor        x_fg_color, x_bg_color;
  1557.   
  1558.   struct icon {
  1559.       short         ic_width, ic_height;    /* overall icon dimensions */
  1560. diff -c /tmp/global.c global.c
  1561. *** /tmp/global.c    Fri Aug 26 09:39:16 1988
  1562. --- global.c    Thu Aug 25 11:21:04 1988
  1563. ***************
  1564. *** 115,120 ****
  1565. --- 115,121 ----
  1566.   int            DEBUG = 0;
  1567.   int            RHS_PANEL = 0;
  1568.   int            INVERSE = 0;
  1569. + int            TRACKING = 1;
  1570.   
  1571.   /************************  Status  ****************************/
  1572.   
  1573. diff -c /tmp/popup.c popup.c
  1574. *** /tmp/popup.c    Fri Aug 26 09:39:18 1988
  1575. --- popup.c    Thu Aug 25 14:17:11 1988
  1576. ***************
  1577. *** 96,102 ****
  1578.       XtTranslations        popdown_actions, pane_actions;
  1579.   
  1580.       menu = XtCreatePopupShell("popup_menu", overrideShellWidgetClass, tool,
  1581. !         menu_args, 0);
  1582.       popdown_actions = XtParseTranslationTable(
  1583.           "<Btn3Up>:MenuPopdown()\n\
  1584.           <LeaveWindow>:MenuPopdown()\n");
  1585. --- 96,102 ----
  1586.       XtTranslations        popdown_actions, pane_actions;
  1587.   
  1588.       menu = XtCreatePopupShell("popup_menu", overrideShellWidgetClass, tool,
  1589. !         menu_args, XtNumber(menu_args));
  1590.       popdown_actions = XtParseTranslationTable(
  1591.           "<Btn3Up>:MenuPopdown()\n\
  1592.           <LeaveWindow>:MenuPopdown()\n");
  1593. diff -c /tmp/flip.c flip.c
  1594. *** /tmp/flip.c    Fri Aug 26 09:39:21 1988
  1595. --- flip.c    Thu Aug 25 15:54:51 1988
  1596. ***************
  1597. *** 371,376 ****
  1598. --- 371,377 ----
  1599.       F_ellipse    *e;
  1600.       F_spline    *s;
  1601.       F_text        *t;
  1602. +     F_compound    *c1;
  1603.       int        p, q;
  1604.       
  1605.       switch(flip_axis) {
  1606. ***************
  1607. *** 397,400 ****
  1608. --- 398,403 ----
  1609.           flip_spline(s, x, y, flip_axis);
  1610.       for (t = c->texts; t != NULL; t = t->next)
  1611.           flip_text(t, x, y, flip_axis);
  1612. +     for (c1 = c->compounds; c1 != NULL; c1 = c1->next)
  1613. +         flip_compound(c1, x, y, flip_axis);
  1614.       }
  1615. diff -c /tmp/rotate.c rotate.c
  1616. *** /tmp/rotate.c    Fri Aug 26 09:39:24 1988
  1617. --- rotate.c    Thu Aug 25 15:59:51 1988
  1618. ***************
  1619. *** 441,446 ****
  1620. --- 441,447 ----
  1621.       F_ellipse    *e;
  1622.       F_spline    *s;
  1623.       F_text        *t;
  1624. +     F_compound    *c1;
  1625.       int        x1, y1, x2, y2;
  1626.   
  1627.       switch(rotate_angle) {
  1628. ***************
  1629. *** 471,474 ****
  1630. --- 472,477 ----
  1631.           rotate_spline(s, x, y, rotate_angle);
  1632.       for (t = c->texts; t != NULL; t = t->next)
  1633.           rotate_text(t, x, y, rotate_angle);
  1634. +     for (c1 = c->compounds; c1 != NULL; c1 = c1->next)
  1635. +         rotate_compound(c1, x, y, rotate_angle);
  1636.       }
  1637. -- 
  1638. Mike Wexler(wyse!mikew)    Phone: (408)433-1000 x1330
  1639.